package com.baor.mall.service.impl;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.baor.common.utils.DateUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.baor.mall.mapper.TTaxonomicMapper;
import com.baor.mall.domain.TTaxonomic;
import com.baor.mall.service.ITTaxonomicService;

/**
 * 商品分类Service业务层处理
 */
@Service
public class TTaxonomicServiceImpl implements ITTaxonomicService
{
    @Autowired
    private TTaxonomicMapper tTaxonomicMapper;

    @Override
    public TTaxonomic selectTTaxonomicById(Long id)
    {
        return tTaxonomicMapper.selectTTaxonomicById(id);
    }

    @Override
    public List<TTaxonomic> selectTTaxonomicList(TTaxonomic tTaxonomic) {
        return tTaxonomicMapper.selectTTaxonomicList(tTaxonomic);
    }

    /**
     * 查询树形结构（核心方法）
     */
    @Override
    public List<TTaxonomic> selectTTaxonomicTree(TTaxonomic tTaxonomic) {
        // 1. 查询所有分类（平面结构）
        List<TTaxonomic> allTaxList = tTaxonomicMapper.selectTTaxonomicList(tTaxonomic);

        // 2. 构建树形结构
        return buildTaxonomicTree(allTaxList);
    }

    /**
     * 构建树形结构的核心逻辑
     */
    private List<TTaxonomic> buildTaxonomicTree(List<TTaxonomic> allTaxList) {
        List<TTaxonomic> treeList = new ArrayList<>();
        Map<Long, TTaxonomic> taxMap = new HashMap<>();

        // 先将所有分类存入Map
        for (TTaxonomic tax : allTaxList) {
            taxMap.put(tax.getId(), tax);
            // 初始化children列表，避免前端出现undefined
            tax.setChildren(new ArrayList<>());
        }

        // 构建树形关系
        for (TTaxonomic tax : allTaxList) {
            Long parentId = tax.getParentId();
            if (parentId == null || parentId == 0) {
                // 一级分类
                treeList.add(tax);
            } else {
                // 二级分类：添加到父分类的children中
                TTaxonomic parentTax = taxMap.get(parentId);
                if (parentTax != null) {
                    parentTax.getChildren().add(tax);
                }
            }
        }
        return treeList;
    }

    /**
     * 查询一级分类列表（供二级分类选择父分类）
     */
    @Override
    public List<TTaxonomic> selectParentTaxList() {
        return tTaxonomicMapper.selectParentTaxList();
    }

    @Override
    public int insertTTaxonomic(TTaxonomic tTaxonomic)
    {
        tTaxonomic.setCreateTime(DateUtils.getNowDate());
        // 一级分类强制设置parentId=0
        if ("1".equals(tTaxonomic.getLevId())) {
            tTaxonomic.setParentId(0L);
        }
        return tTaxonomicMapper.insertTTaxonomic(tTaxonomic);
    }

    @Override
    public int updateTTaxonomic(TTaxonomic tTaxonomic)
    {
        // 若修改为一级分类，强制parentId=0
        if ("1".equals(tTaxonomic.getLevId())) {
            tTaxonomic.setParentId(0L);
        }
        return tTaxonomicMapper.updateTTaxonomic(tTaxonomic);
    }

    @Override
    public int deleteTTaxonomicByIds(Long[] ids)
    {
        return tTaxonomicMapper.deleteTTaxonomicByIds(ids);
    }

    @Override
    public int deleteTTaxonomicById(Long id)
    {
        return tTaxonomicMapper.deleteTTaxonomicById(id);
    }
}